// 全局变量
let socket;
let temperatureChart;
let humidityChart;
let isAutoControl = true;
let lastUpdateTime = new Date();

// 传感器数据历史记录
const sensorHistory = {
    temperature: {
        labels: [],
        values: []
    },
    humidity: {
        labels: [],
        values: []
    }
};

// 初始化函数
function init() {
    // 连接Socket.IO
    connectSocketIO();
    
    // 初始化图表
    initCharts();
    
    // 初始化设备控制
    initDeviceControls();
    
    // 添加日志消息
    addLogMessage('系统初始化完成', 'info');
    
    // 生成模拟数据（仅用于演示）
    generateMockData();
}

// 生成模拟数据
function generateMockData() {
    // 初始模拟数据 - 室内环境参数
    const mockData = {
        temperature: 24.0,  // 室内温度通常在22-26度之间
        Humidity: 55.0,    // 室内湿度通常在45-65%之间
        WindSpeed: 0.5,    // 室内风速很小
        LightLux: 1000,    // 室内光照适中
        soilHumidity: 45.0, // 盆栽土壤湿度
        UV: 1.0,           // 室内UV很低
        AQI: 50            // 室内空气质量通常较好
    };
    
    // 更新传感器数据
    updateSensorData(mockData);
    
    // 模拟设备状态
    const mockDeviceStatus = {
        IrrigationPumpStatus: 0,
        FanLevel: 1,  // 室内风扇通常在低档位
        LEDLux: 2     // 室内光照适中
    };
    
    // 更新设备状态
    updateDeviceStatus(mockDeviceStatus);
    
    // 设置定时器，每3秒更新一次模拟数据
    setInterval(function() {
        // 随机波动数据 - 室内环境参数变化更微小，并添加时间趋势
        // 室内温度范围更窄，波动更小，随时间变化
        mockData.temperature = fluctuateValue(mockData.temperature, 22, 26, 0.2, true, 'temperature');
        // 室内湿度变化缓慢，与温度呈反相关
        mockData.Humidity = fluctuateValue(mockData.Humidity, 45, 65, 1, true, 'humidity');
        // 室内风速很小，与温度相关
        mockData.WindSpeed = fluctuateValue(mockData.WindSpeed, 0, 2, 0.1, true, 'wind');
        // 室内光照变化取决于窗户和灯光，随时间变化
        mockData.LightLux = fluctuateValue(mockData.LightLux, 800, 1500, 50, true, 'light');
        
        // 盆栽土壤湿度变化缓慢，与浇水相关
        // 如果水泵开启，土壤湿度会缓慢上升
        if (mockDeviceStatus.IrrigationPumpStatus === 1) {
            // 水泵开启时，土壤湿度缓慢上升
            const soilChange = 0.5;  // 每次更新增加0.5%
            mockData.soilHumidity = Math.min(55, mockData.soilHumidity + soilChange);
        } else {
            // 水泵关闭时，土壤湿度缓慢下降
            mockData.soilHumidity = fluctuateValue(mockData.soilHumidity, 35, 55, 0.5, true, 'soil');
            // 确保土壤湿度有缓慢下降趋势
            mockData.soilHumidity = Math.max(35, mockData.soilHumidity - 0.1);
        }
        
        // 室内UV很低，与光照相关
        mockData.UV = fluctuateValue(mockData.UV, 0.5, 2, 0.1, true, 'uv');
        
        // 室内空气质量相对稳定，与风扇运行相关
        if (mockDeviceStatus.FanLevel > 0) {
            // 风扇开启时，空气质量缓慢改善
            const aqiChange = mockDeviceStatus.FanLevel * 0.5;  // 风扇档位越高，改善越快
            mockData.AQI = Math.max(30, mockData.AQI - aqiChange);
        } else {
            // 风扇关闭时，空气质量缓慢恶化
            mockData.AQI = Math.round(fluctuateValue(mockData.AQI, 30, 80, 2, true, 'aqi'));
            // 确保空气质量有缓慢上升趋势
            mockData.AQI = Math.min(80, mockData.AQI + 0.2);
        }
        
        // 更新传感器数据
        updateSensorData(mockData);
        
        // 随机更新设备状态（仅在自动控制模式下）
        if (isAutoControl) {
            // 根据温度和湿度自动控制设备 - 调整为室内环境的控制逻辑
            // 土壤湿度低于38%时启动水泵
            const newPumpStatus = mockData.soilHumidity < 38 ? 1 : 0;
            if (newPumpStatus !== mockDeviceStatus.IrrigationPumpStatus) {
                mockDeviceStatus.IrrigationPumpStatus = newPumpStatus;
                // 只在状态变化时添加日志
                if (newPumpStatus === 1) {
                    addLogMessage('智能控制：盆栽土壤湿度低于38%，启动水泵', 'warning');
                } else {
                    addLogMessage('智能控制：盆栽土壤湿度已恢复，关闭水泵', 'info');
                }
            }
            
            // 室内温度控制更精细
            // 22-23度：风扇0档
            // 23-24度：风扇1档
            // 24-25度：风扇2档
            // 25-26度：风扇3档
            // >26度：风扇4-5档
            let newFanLevel = 0;
            if (mockData.temperature < 23) {
                newFanLevel = 0;
            } else if (mockData.temperature < 24) {
                newFanLevel = 1;
            } else if (mockData.temperature < 25) {
                newFanLevel = 2;
            } else if (mockData.temperature < 26) {
                newFanLevel = 3;
            } else {
                newFanLevel = Math.min(Math.floor((mockData.temperature - 26) * 2) + 4, 5);
            }
            
            if (newFanLevel !== mockDeviceStatus.FanLevel) {
                mockDeviceStatus.FanLevel = newFanLevel;
                // 只在状态变化时添加日志
                if (newFanLevel > 0) {
                    addLogMessage('智能控制：室内温度' + mockData.temperature.toFixed(1) + '°C，风扇调至' + newFanLevel + '档', 
                        newFanLevel > 2 ? 'warning' : 'info');
                } else {
                    addLogMessage('智能控制：室内温度适宜，关闭风扇', 'info');
                }
            }
            
            // 室内光照控制更精细
            // >1200：LED灯0档
            // 1000-1200：LED灯1档
            // 900-1000：LED灯2档
            // 800-900：LED灯3档
            // <800：LED灯4-5档
            let newLEDLevel = 0;
            if (mockData.LightLux > 1200) {
                newLEDLevel = 0;
            } else if (mockData.LightLux > 1000) {
                newLEDLevel = 1;
            } else if (mockData.LightLux > 900) {
                newLEDLevel = 2;
            } else if (mockData.LightLux > 800) {
                newLEDLevel = 3;
            } else {
                newLEDLevel = Math.min(Math.floor((800 - mockData.LightLux) / 50) + 4, 5);
            }
            
            if (newLEDLevel !== mockDeviceStatus.LEDLux) {
                mockDeviceStatus.LEDLux = newLEDLevel;
                // 只在状态变化时添加日志
                if (newLEDLevel > 0) {
                    addLogMessage('智能控制：室内光照' + mockData.LightLux.toFixed(1) + 'lux，LED灯调至' + newLEDLevel + '档', 
                        newLEDLevel > 3 ? 'warning' : 'info');
                } else {
                    addLogMessage('智能控制：室内光照充足，关闭LED灯', 'info');
                }
            }
            
            // 更新设备状态
            updateDeviceStatus(mockDeviceStatus);
        }
    }, 3000);
}

// 在指定范围内波动数值，添加时间趋势
function fluctuateValue(currentValue, min, max, maxChange, isIndoor = true, paramType = null) {
    // 室内环境波动更小
    if (isIndoor) {
        // 室内环境波动减小到原来的30%
        maxChange = maxChange * 0.3;
    }
    
    // 获取当前时间信息
    const now = new Date();
    const hourOfDay = now.getHours();
    const minuteOfHour = now.getMinutes();
    
    // 基础趋势值 - 根据参数类型和时间计算
    let baseTrend = 0;
    
    // 根据参数类型添加不同的时间趋势
    if (paramType === 'temperature') {
        // 温度在白天(8-18点)缓慢升高，晚上缓慢降低
        let dayProgress = 0;
        if (hourOfDay >= 8 && hourOfDay < 18) {
            // 白天时段内的进度(0-1)
            dayProgress = (hourOfDay - 8 + minuteOfHour/60) / 10;
            // 温度曲线：上午升高，下午略微下降
            baseTrend = Math.sin(dayProgress * Math.PI) * 1.5;
        } else {
            // 夜间时段
            let nightProgress;
            if (hourOfDay < 8) {
                nightProgress = (hourOfDay + 24 - 18 + minuteOfHour/60) / 14;
            } else { // hourOfDay >= 18
                nightProgress = (hourOfDay - 18 + minuteOfHour/60) / 14;
            }
            // 夜间温度缓慢下降后缓慢上升
            baseTrend = -Math.sin(nightProgress * Math.PI) * 1.0;
        }
    } else if (paramType === 'humidity') {
        // 湿度与温度相反，温度高时湿度低
        if (hourOfDay >= 8 && hourOfDay < 18) {
            const dayProgress = (hourOfDay - 8 + minuteOfHour/60) / 10;
            // 湿度曲线：上午降低，下午略微升高
            baseTrend = -Math.sin(dayProgress * Math.PI) * 5;
        } else {
            let nightProgress;
            if (hourOfDay < 8) {
                nightProgress = (hourOfDay + 24 - 18 + minuteOfHour/60) / 14;
            } else { // hourOfDay >= 18
                nightProgress = (hourOfDay - 18 + minuteOfHour/60) / 14;
            }
            baseTrend = Math.sin(nightProgress * Math.PI) * 3;
        }
    } else if (paramType === 'light') {
        // 光照强度随时间变化
        if (hourOfDay >= 6 && hourOfDay < 18) { // 白天
            const dayProgress = (hourOfDay - 6 + minuteOfHour/60) / 12;
            // 光照曲线：早晨升高，中午最强，傍晚降低
            baseTrend = Math.sin(dayProgress * Math.PI) * 300;
        } else { // 夜间
            baseTrend = -200; // 夜间光照较低
        }
    }
    
    // 生成随机波动，使用更自然的分布
    // 使用Box-Muller变换生成近似正态分布的随机数
    let u = 0, v = 0;
    while(u === 0) u = Math.random(); // 不能为0
    while(v === 0) v = Math.random();
    const z = Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
    
    // 将正态分布的随机数缩放到合适的范围
    const randomFluctuation = z * (maxChange / 3);
    
    // 计算新值 = 当前值 + 趋势变化 + 随机波动
    let newValue = currentValue + baseTrend * 0.05 + randomFluctuation;
    
    // 确保在范围内
    newValue = Math.max(min, Math.min(max, newValue));
    
    // 保留一位小数
    return Math.round(newValue * 10) / 10;
}

// 连接Socket.IO
function connectSocketIO() {
    socket = io();
    
    // 连接事件
    socket.on('connect', function() {
        $('#connection-status').removeClass('bg-danger disconnected').addClass('bg-success').text('已连接');
        addLogMessage('已连接到服务器', 'success');
    });
    
    // 断开连接事件
    socket.on('disconnect', function() {
        $('#connection-status').removeClass('bg-success').addClass('bg-danger disconnected').text('已断开');
        addLogMessage('与服务器断开连接', 'error');
    });
    
    // 传感器数据更新事件
    socket.on('sensor_data_update', function(data) {
        updateSensorData(data);
        addLogMessage('接收到传感器数据更新', 'info');
    });
    
    // 设备状态更新事件
    socket.on('device_status_update', function(data) {
        updateDeviceStatus(data);
        addLogMessage('接收到设备状态更新', 'info');
    });
}

// 初始化图表
function initCharts() {
    // 温度图表
    const temperatureCtx = document.getElementById('temperatureChart').getContext('2d');
    temperatureChart = new Chart(temperatureCtx, {
        type: 'line',
        data: {
            labels: [],
            datasets: [{
                label: '温度 (°C)',
                data: [],
                borderColor: 'rgb(255, 99, 132)',
                backgroundColor: 'rgba(255, 99, 132, 0.2)',
                borderWidth: 2,
                tension: 0.3,
                fill: true
            }]
        },
        options: {
            responsive: true,
            maintainAspectRatio: false,
            plugins: {
                title: {
                    display: true,
                    text: '温度变化趋势'
                },
                legend: {
                    display: false
                }
            },
            scales: {
                y: {
                    beginAtZero: false,
                    suggestedMin: 21,  // 室内温度下限
                    suggestedMax: 27,  // 室内温度上限
                    ticks: {
                        stepSize: 0.5  // 更精细的刻度
                    }
                }
            }
        }
    });
    
    // 湿度图表
    const humidityCtx = document.getElementById('humidityChart').getContext('2d');
    humidityChart = new Chart(humidityCtx, {
        type: 'line',
        data: {
            labels: [],
            datasets: [{
                label: '湿度 (%)',
                data: [],
                borderColor: 'rgb(54, 162, 235)',
                backgroundColor: 'rgba(54, 162, 235, 0.2)',
                borderWidth: 2,
                tension: 0.3,
                fill: true
            }]
        },
        options: {
            responsive: true,
            maintainAspectRatio: false,
            plugins: {
                title: {
                    display: true,
                    text: '湿度变化趋势'
                },
                legend: {
                    display: false
                }
            },
            scales: {
                y: {
                    beginAtZero: false,
                    suggestedMin: 40,  // 室内湿度下限
                    suggestedMax: 70,  // 室内湿度上限
                    ticks: {
                        stepSize: 5  // 更合适的刻度
                    }
                }
            }
        }
    });
}

// 初始化设备控制
function initDeviceControls() {
    // 水泵开关
    $('#pumpSwitch').change(function() {
        if (!isAutoControl) {
            const status = $(this).prop('checked') ? 1 : 0;
            controlDevice({ IrrigationPumpStatus: status });
        } else {
            // 如果是自动控制模式，恢复开关状态
            $(this).prop('checked', $('#pumpSwitch').data('status') === 1);
            showAutoControlAlert();
        }
    });
    
    // 风扇控制
    $('#fanRange').on('input', function() {
        $('#fanLevel').text($(this).val());
    });
    
    $('#fanRange').change(function() {
        if (!isAutoControl) {
            const level = parseInt($(this).val());
            controlDevice({ FanLevel: level });
        } else {
            // 如果是自动控制模式，恢复滑块状态
            $(this).val($('#fanRange').data('level'));
            $('#fanLevel').text($(this).val());
            showAutoControlAlert();
        }
    });
    
    // LED灯控制
    $('#ledRange').on('input', function() {
        $('#ledLevel').text($(this).val());
    });
    
    $('#ledRange').change(function() {
        if (!isAutoControl) {
            const level = parseInt($(this).val());
            controlDevice({ LEDLux: level });
        } else {
            // 如果是自动控制模式，恢复滑块状态
            $(this).val($('#ledRange').data('level'));
            $('#ledLevel').text($(this).val());
            showAutoControlAlert();
        }
    });
    
    // 自动控制按钮
    $('#autoControlBtn').click(function() {
        isAutoControl = true;
        updateControlMode();
        addLogMessage('已切换到智能控制模式', 'success');
    });
    
    // 手动控制按钮
    $('#manualControlBtn').click(function() {
        isAutoControl = false;
        updateControlMode();
        addLogMessage('已切换到手动控制模式', 'warning');
    });
    
    // 初始化控制模式
    updateControlMode();
}

// 更新控制模式UI
function updateControlMode() {
    if (isAutoControl) {
        $('#autoControlBtn').addClass('btn-primary').removeClass('btn-outline-primary');
        $('#manualControlBtn').addClass('btn-outline-secondary').removeClass('btn-secondary');
        $('.form-range, .form-check-input').prop('disabled', true);
    } else {
        $('#autoControlBtn').addClass('btn-outline-primary').removeClass('btn-primary');
        $('#manualControlBtn').addClass('btn-secondary').removeClass('btn-outline-secondary');
        $('.form-range, .form-check-input').prop('disabled', false);
    }
}

// 显示自动控制模式警告
function showAutoControlAlert() {
    const alertHtml = `
        <div class="alert alert-warning alert-dismissible fade show" role="alert">
            <strong>提示：</strong> 当前为智能控制模式，请切换到手动控制模式后再操作设备。
            <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
        </div>
    `;
    
    // 移除已有的警告
    $('.alert-warning').remove();
    
    // 添加新警告
    $('.card-body').first().prepend(alertHtml);
    
    // 3秒后自动关闭
    setTimeout(function() {
        $('.alert-warning').alert('close');
    }, 3000);
}

// 更新传感器数据
function updateSensorData(data) {
    // 更新UI显示
    $('#temperature').text(`${data.temperature.toFixed(1)} °C`);
    $('#humidity').text(`${data.Humidity.toFixed(1)} %`);
    $('#windSpeed').text(`${data.WindSpeed.toFixed(1)} m/s`);
    $('#lightLux').text(`${data.LightLux.toFixed(1)} lux`);
    $('#soilHumidity').text(`${data.soilHumidity.toFixed(1)} %`);
    $('#uv').text(data.UV.toFixed(1));
    $('#aqi').text(data.AQI);
    
    // 更新最后更新时间
    lastUpdateTime = new Date();
    $('#lastUpdate').text(formatDateTime(lastUpdateTime));
    
    // 更新图表数据
    updateChartData(data);
}

// 更新图表数据
function updateChartData(data) {
    const timeLabel = formatTime(new Date());
    
    // 更新温度图表
    sensorHistory.temperature.labels.push(timeLabel);
    sensorHistory.temperature.values.push(data.temperature);
    
    // 保持最多显示10个数据点
    if (sensorHistory.temperature.labels.length > 10) {
        sensorHistory.temperature.labels.shift();
        sensorHistory.temperature.values.shift();
    }
    
    temperatureChart.data.labels = sensorHistory.temperature.labels;
    temperatureChart.data.datasets[0].data = sensorHistory.temperature.values;
    temperatureChart.update();
    
    // 更新湿度图表
    sensorHistory.humidity.labels.push(timeLabel);
    sensorHistory.humidity.values.push(data.Humidity);
    
    // 保持最多显示10个数据点
    if (sensorHistory.humidity.labels.length > 10) {
        sensorHistory.humidity.labels.shift();
        sensorHistory.humidity.values.shift();
    }
    
    humidityChart.data.labels = sensorHistory.humidity.labels;
    humidityChart.data.datasets[0].data = sensorHistory.humidity.values;
    humidityChart.update();
}

// 更新设备状态
function updateDeviceStatus(data) {
    // 更新水泵状态
    const pumpStatus = data.IrrigationPumpStatus;
    $('#pumpSwitch').prop('checked', pumpStatus === 1);
    $('#pumpStatus').text(pumpStatus === 1 ? '开启' : '关闭');
    $('#pumpSwitch').data('status', pumpStatus);
    
    // 更新风扇状态
    const fanLevel = data.FanLevel;
    $('#fanRange').val(fanLevel);
    $('#fanLevel').text(fanLevel);
    $('#fanRange').data('level', fanLevel);
    
    // 更新LED灯状态
    const ledLevel = data.LEDLux;
    $('#ledRange').val(ledLevel);
    $('#ledLevel').text(ledLevel);
    $('#ledRange').data('level', ledLevel);
    
    addLogMessage(`设备状态已更新: 水泵=${pumpStatus}, 风扇=${fanLevel}, LED=${ledLevel}`, 'info');
}

// 控制设备
function controlDevice(data) {
    socket.emit('control_device', data, function(response) {
        if (response.success) {
            addLogMessage(`设备控制命令已发送: ${JSON.stringify(data)}`, 'success');
        } else {
            addLogMessage(`设备控制命令发送失败: ${response.message}`, 'error');
        }
    });
}

// 添加日志消息
function addLogMessage(message, type = 'info') {
    const timestamp = formatTime(new Date());
    const logEntry = `<div class="log-entry log-${type}">[${timestamp}] ${message}</div>`;
    $('#logMessages').append(logEntry);
    
    // 滚动到底部
    const logContainer = document.querySelector('.log-container');
    logContainer.scrollTop = logContainer.scrollHeight;
    
    // 限制日志条数
    const maxLogEntries = 100;
    const logEntries = $('.log-entry');
    if (logEntries.length > maxLogEntries) {
        logEntries.slice(0, logEntries.length - maxLogEntries).remove();
    }
}

// 格式化时间 (HH:MM:SS)
function formatTime(date) {
    return date.toTimeString().split(' ')[0];
}

// 格式化日期时间 (YYYY-MM-DD HH:MM:SS)
function formatDateTime(date) {
    return `${date.getFullYear()}-${padZero(date.getMonth() + 1)}-${padZero(date.getDate())} ${formatTime(date)}`;
}

// 数字补零
function padZero(num) {
    return num.toString().padStart(2, '0');
}

// 页面加载完成后初始化
$(document).ready(function() {
    init();
});